Python HTTP klientu analīze: padziļināts ieskats Requests, httpx un urllib3

Mūsdienu programmatūras izstrādes pasaulē komunikācija ir galvenais. Lietojumprogrammas reti pastāv izolēti; tās sazinās ar datu bāzēm, trešo pušu pakalpojumiem un citiem mikropakalpojumiem, galvenokārt izmantojot API, kas darbojas, izmantojot hiperteksta pārsūtīšanas protokolu (HTTP). Python izstrādātājiem šo HTTP pieprasījumu veikšana ir fundamentāls uzdevums, un bibliotēka, kuru izvēlaties šim darbam, var būtiski ietekmēt jūsu produktivitāti, lietojumprogrammas veiktspēju un koda uzturējamību.

Python ekosistēma piedāvā plašu rīku klāstu šim nolūkam, bet trīs nosaukumi nemainīgi izceļas: urllib3, robustais pamats; Requests, universāli iemīļotais standarts; un httpx, modernais, asinhrono darbību spējīgais pretendents. Izvēle starp tiem nav par vienas "labākās" bibliotēkas atrašanu, bet gan par to unikālo stipro pušu izpratni un pareizā rīka izvēli jūsu konkrētajām vajadzībām. Šis ceļvedis sniegs dziļu, profesionālu salīdzinājumu, lai palīdzētu jums pieņemt šo pamatoto lēmumu.

Pamatu izpratne: kas ir HTTP klients?

Būtībā HTTP klients ir programmatūras daļa, kas paredzēta HTTP pieprasījumu sūtīšanai uz serveri un saņemto HTTP atbilžu apstrādei. Šī vienkāršā definīcija slēpj lielu sarežģītību. Robusta HTTP klientu bibliotēka nodrošina daudzas zema līmeņa detaļas, tostarp:

• Tīkla ligzdu un savienojumu pārvaldība.
• Pareiza HTTP pieprasījumu formatēšana ar galvenēm, pamattekstiem un metodēm (GET, POST, PUT utt.).
• Pāradresāciju un taimautu apstrāde.
• Sīkfailu un sesiju pārvaldība stāvokļa uzturēšanai komunikācijā.
• Dažādu satura kodējumu (piemēram, JSON vai formas datu) apstrāde.
• SSL/TLS apstrāde drošiem HTTPS savienojumiem.
• Savienojumu atkārtota izmantošana labākai veiktspējai (savienojumu apvienošana).

Lai gan Python standarta bibliotēka ietver moduļus, piemēram, urllib.request, tie bieži tiek uzskatīti par pārāk zema līmeņa un apgrūtinošiem ikdienas lietošanai. Tas ir novedis pie jaudīgāku, lietotājam draudzīgāku trešo pušu bibliotēku izstrādes, kas abstrahē šo sarežģītību, ļaujot izstrādātājiem koncentrēties uz savas lietojumprogrammas loģiku.

Klasiskais čempions: urllib3

Pirms mēs apspriežam augstāka līmeņa bibliotēkas, ir svarīgi saprast urllib3. Tā ir viena no visvairāk lejupielādētajām paketēm PyPI, nevis tāpēc, ka vairums izstrādātāju to lieto tieši, bet gan tāpēc, ka tā ir jaudīgs, uzticams dzinējs, kas darbina neskaitāmas citas augsta līmeņa bibliotēkas, īpaši Requests.

Kas ir urllib3?

urllib3 ir jaudīgs, uz stabilitāti vērsts HTTP klients Python valodai. Tā galvenais uzsvars ir uz uzticama un efektīva pamata nodrošināšanu HTTP komunikācijai. Tā nav izstrādāta ar tādu pašu uzsvaru uz API eleganci kā Requests, bet gan uz pareizību, veiktspēju un detalizētu kontroli.

Galvenās funkcijas un stiprās puses

• Savienojumu apvienošana (Connection Pooling): Šī, iespējams, ir tās vissvarīgākā funkcija. urllib3 pārvalda savienojumu kopas. Kad veicat pieprasījumu uz resursdatoru, ar kuru jau esat sazinājies, tā atkārtoti izmanto esošu savienojumu, nevis izveido jaunu. Tas krasi samazina secīgu pieprasījumu latentumu, jo tiek novērstas TCP un TLS rokasspiedienu pieskaitāmās izmaksas.
• Pavediendrošība: Vienu PoolManager instanci var koplietot starp vairākiem pavedieniem, padarot to par robustu izvēli daudzpavedienu lietojumprogrammām.
• Robusta kļūdu apstrāde un atkārtoti mēģinājumi: Tā nodrošina sarežģītus mehānismus neveiksmīgu pieprasījumu atkārtošanai, papildinātus ar konfigurējamām atlikšanas stratēģijām, kas ir būtiski, veidojot noturīgas lietojumprogrammas, kas sazinās ar potenciāli nestabiliem pakalpojumiem.
• Detalizēta kontrole: Tā piedāvā plašu konfigurācijas opciju klāstu, ļaujot izstrādātājiem precīzi noregulēt taimautus, TLS verifikāciju, starpniekservera iestatījumus un daudz ko citu.
• Failu augšupielāde: Tai ir lielisks atbalsts multipart form-data kodēšanai, kas atvieglo efektīvu failu augšupielādi.

Koda piemērs: GET pieprasījuma veikšana

urllib3 lietošana ir izvērstāka nekā tās augstākā līmeņa līdziniekiem, bet tā joprojām ir saprotama. Parasti jūs mijiedarbojaties ar PoolManager instanci.

            
import urllib3
import json

# It's recommended to create a single PoolManager instance and reuse it
http = urllib3.PoolManager()

# Define the target URL
url = "https://api.github.com/users/python"

# Make the request
# Note: The request method is passed as a string ('GET')
# The response object is an HTTPResponse instance
response = http.request("GET", url, headers={"User-Agent": "My-Urllib3-App/1.0"})

# Check the response status
if response.status == 200:
    # The data is returned as a bytes object and needs to be decoded
    data_bytes = response.data
    data_str = data_bytes.decode("utf-8")
    
    # Manually parse the JSON
    user_data = json.loads(data_str)
    
    print(f"User Name: {user_data['name']}")
    print(f"Public Repos: {user_data['public_repos']}")
else:
    print(f"Error: Received status code {response.status}")

# The connection is automatically released back to the pool

            

              
                Copy
              
            
          

Kad lietot urllib3

• Kad veidojat bibliotēku vai ietvaru, kam nepieciešams veikt HTTP pieprasījumus, un vēlaties rūpīgi pārvaldīt atkarības.
• Kad nepieciešama maksimāla veiktspēja un kontrole pār savienojumu pārvaldību un atkārtotu mēģinājumu loģiku.
• Vecākās sistēmās vai ierobežotās vidēs, kur jāpaļaujas uz bibliotēku, kas bieži tiek iekļauta citās lielās paketēs.

Vērtējums par urllib3

Plusi: Augsta veiktspēja, pavediendroša, robusta un piedāvā dziļu kontroli pār pieprasījuma dzīves ciklu.
Mīnusi: API ir izvērsts un mazāk intuitīvs. Tas prasa manuālu darbu tādiem biežiem uzdevumiem kā JSON dekodēšana un pieprasījuma parametru kodēšana.

Tautas izvēle: requests - "HTTP cilvēkiem"

Vairāk nekā desmit gadus requests ir bijis de-facto standarts HTTP pieprasījumu veikšanai Python valodā. Tās slavenais sauklis "HTTP cilvēkiem" lieliski iemieso tās dizaina filozofiju. Tā nodrošina skaistu, vienkāršu un elegantu API, kas slēpj urllib3 pārvaldīto sarežģītību.

Kas ir requests?

requests ir augsta līmeņa HTTP bibliotēka, kas koncentrējas uz izstrādātāja pieredzi un lietošanas ērtumu. Tā ietin urllib3 jaudu intuitīvā saskarnē, padarot biežus uzdevumus neticami vienkāršus, vienlaikus nodrošinot piekļuvi jaudīgām funkcijām, kad tas nepieciešams.

Galvenās funkcijas un stiprās puses

• Vienkārša, eleganta API: Ar šo API ir prieks strādāt. GET pieprasījuma veikšana ir viena, salasāma koda rinda.
• Sesijas objekti: Sesijas objekti ir stūrakmens funkcija. Tie saglabā parametrus starp pieprasījumiem, automātiski pārvalda sīkfailus un, vissvarīgākais, zem pārsega izmanto urllib3 savienojumu apvienošanu. Session izmantošana ir ieteicamais veids, kā sasniegt augstu veiktspēju ar requests.
• Iebūvēta JSON dekodēšana: Mijiedarbība ar JSON API ir triviāla. Atbildes objektam ir .json() metode, kas automātiski dekodē atbildes pamattekstu un atgriež Python vārdnīcu vai sarakstu.
• Automātiska satura dekompresija: Tā caurspīdīgi apstrādā saspiestus atbildes datus (gzip, deflate), tāpēc jums par to nav jādomā.
• Gracioza sarežģītu datu apstrāde: Formas datu vai JSON kravu sūtīšana ir tikpat vienkārša kā vārdnīcas nodošana data vai json parametram.
• Starptautiskie domēni un URL: Lielisks, gatavs atbalsts globālajam tīmeklim.

Koda piemērs: GET pieprasījuma veikšana un JSON apstrāde

Salīdziniet šī piemēra vienkāršību ar urllib3 versiju. Ievērojiet manuālas dekodēšanas vai JSON parsēšanas trūkumu.

            
import requests

# The recommended approach for multiple requests to the same host
with requests.Session() as session:
    session.headers.update({"User-Agent": "My-Requests-App/1.0"})

    url = "https://api.github.com/users/python"

    try:
        # Making the request is a single function call
        response = session.get(url)
        
        # Raise an exception for bad status codes (4xx or 5xx)
        response.raise_for_status()
        
        # The .json() method handles decoding and parsing
        user_data = response.json()
        
        print(f"User Name: {user_data['name']}")
        print(f"Public Repos: {user_data['public_repos']}")

    except requests.exceptions.RequestException as e:
        print(f"An error occurred: {e}")


            

              
                Copy
              
            
          

Kad lietot requests

• Lielākajai daļai sinhrono HTTP uzdevumu lietojumprogrammās, skriptos un datu zinātnes projektos.
• Mijiedarbojoties ar REST API.
• Ātrai prototipēšanai un iekšējo rīku veidošanai.
• Kad jūsu galvenais mērķis ir koda lasāmība un izstrādes ātrums sinhronai tīkla I/O.

Apsveramie ierobežojumi

Lielākais requests ierobežojums mūsdienās ir tas, ka tās API ir stingri sinhrona. Tā bloķē izpildi, līdz tiek saņemta atbilde. Tas padara to nepiemērotu augstas konkurences lietojumprogrammām, kas veidotas uz asinhroniem ietvariem, piemēram, asyncio, FastAPI vai Starlette. Lai gan to var izmantot pavedienu kopā, šī pieeja ir mazāk efektīva nekā dabiskā asinhronā I/O, lai apstrādātu tūkstošiem vienlaicīgu savienojumu.

Vērtējums par requests

Plusi: Neticami viegli lietojama, ļoti lasāma, bagātīgs funkciju komplekts, milzīga kopiena un lieliska dokumentācija.
Mīnusi: Tikai sinhrona. Tas ir būtisks trūkums modernām, augstas veiktspējas, I/O saistītām lietojumprogrammām.

Modernais pretendents: httpx - asinhronai darbībai gatavs pēctecis

httpx ir moderns, pilnvērtīgs HTTP klients, kas radās, lai risinātu requests ierobežojumus, galvenokārt tās asinhronā atbalsta trūkumu. Tā ir izstrādāta kā nākamās paaudzes klients, kas aptver modernas Python funkcijas un tīmekļa protokolus, vienlaikus piedāvājot pazīstamu API tiem, kas nāk no requests.

Kas ir httpx?

httpx ir daudzpusīgs HTTP klients Python valodai, kas nodrošina gan sinhronu, gan asinhronu API. Tās galvenā priekšrocība ir pirmklasīgs atbalsts async/await sintaksei. Turklāt tas nodrošina atbalstu moderniem tīmekļa protokoliem, piemēram, HTTP/2 un HTTP/3, kas var piedāvāt ievērojamus veiktspējas uzlabojumus.

Galvenās funkcijas un stiprās puses

• Sinhronais un asinhronais atbalsts: Šī ir tās noteicošā iezīme. Jūs varat izmantot to pašu bibliotēku un ļoti līdzīgu API gan tradicionāliem sinhroniem skriptiem, gan augstas veiktspējas asinhronām lietojumprogrammām. Šī unifikācija vienkāršo atkarību pārvaldību un samazina mācīšanās līkni.
• HTTP/2 un HTTP/3 atbalsts: Atšķirībā no requests, httpx var sazināties, izmantojot HTTP/2. Šis protokols ļauj multipleksēt — sūtīt vairākus pieprasījumus un atbildes pa vienu savienojumu vienlaicīgi —, kas var dramatiski paātrināt saziņu ar moderniem serveriem, kas to atbalsta.
• Ar requests saderīgs API: API tika apzināti izstrādāts, lai daudzos gadījumos būtu tiešs aizstājējs requests. Funkcijas kā httpx.get() un objekti kā httpx.Client() (requests.Session() ekvivalents) liksies uzreiz pazīstami.
• Paplašināms transporta API: Tam ir tīrs, labi definēts transporta API, kas atvieglo pielāgotu adapteru rakstīšanu tādām lietām kā imitācija (mocking), kešatmiņa vai pielāgoti tīkla protokoli.

Koda piemēri: sinhroni, asinhroni un klienti

Vispirms sinhronais piemērs. Ievērojiet, cik tas ir gandrīz identisks requests kodam.

            
# Synchronous httpx code
import httpx

url = "https://api.github.com/users/python-httpx"

with httpx.Client(headers={"User-Agent": "My-HTTPX-App/1.0"}) as client:
    try:
        response = client.get(url)
        response.raise_for_status()
        user_data = response.json()
        
        print(f"(Sync) User Name: {user_data['name']}")
        print(f"(Sync) Public Repos: {user_data['public_repos']}")

    except httpx.RequestError as e:
        print(f"An error occurred: {e}")

            

              
                Copy
              
            
          

Tagad asinhronā versija. Struktūra ir tāda pati, bet tā izmanto async/await, lai veiktu nebloķējošu I/O.

            
# Asynchronous httpx code
import httpx
import asyncio

async def fetch_github_user():
    url = "https://api.github.com/users/python-httpx"
    
    # Use AsyncClient for async operations
    async with httpx.AsyncClient(headers={"User-Agent": "My-HTTPX-App/1.0"}) as client:
        try:
            # The 'await' keyword pauses execution until the network call completes
            response = await client.get(url)
            response.raise_for_status()
            user_data = response.json()
            
            print(f"(Async) User Name: {user_data['name']}")
            print(f"(Async) Public Repos: {user_data['public_repos']}")

        except httpx.RequestError as e:
            print(f"An error occurred: {e}")

# Run the async function
asyncio.run(fetch_github_user())

            

              
                Copy
              
            
          

Kad lietot httpx

• Jebkuram jaunam projektam, kas tiek sākts šodien. Tās sinhronā/asinhronā dualitāte padara to par nākotnes drošu izvēli.
• Veidojot lietojumprogrammas ar asinhroniem ietvariem, piemēram, FastAPI, Starlette, Sanic vai Django 3+.
• Kad nepieciešams veikt lielu skaitu vienlaicīgu I/O saistītu pieprasījumu (piemēram, izsaucot tūkstošiem API).
• Kad nepieciešams sazināties ar serveriem, kas izmanto HTTP/2 veiktspējas uzlabošanai.

Vērtējums par httpx

Plusi: Piedāvā gan sinhrono, gan asinhrono API, atbalsta HTTP/2, ir moderns un tīrs dizains, un nodrošina pazīstamu API requests lietotājiem.
Mīnusi: Kā jaunāks projekts, tā trešo pušu spraudņu ekosistēma nav tik plaša kā requests, lai gan tā strauji aug.

Funkciju salīdzinājums: īsumā

Šis kopsavilkums sniedz ātru atsauci uz galvenajām atšķirībām starp trim bibliotēkām.

Funkcija: Augsta līmeņa, lietotājam draudzīgs API

• urllib3: Nē. Zema līmeņa un izvērsts.
• requests: Jā. Tā ir tās galvenā priekšrocība.
• httpx: Jā. Izstrādāts, lai būtu pazīstams `requests` lietotājiem.

Funkcija: Sinhronais API

• urllib3: Jā.
• requests: Jā.
• httpx: Jā.

Funkcija: Asinhronais API (async/await)

• urllib3: Nē.
• requests: Nē.
• httpx: Jā. Tā ir tās galvenā atšķirība.

Funkcija: HTTP/2 atbalsts

• urllib3: Nē.
• requests: Nē.
• httpx: Jā.

Funkcija: Savienojumu apvienošana (Connection Pooling)

• urllib3: Jā. Pamatfunkcija.
• requests: Jā (izmantojot Session objektus).
• httpx: Jā (izmantojot Client un AsyncClient objektus).

Funkcija: Iebūvēta JSON dekodēšana

• urllib3: Nē. Nepieciešama manuāla dekodēšana un parsēšana.
• requests: Jā (izmantojot response.json()).
• httpx: Jā (izmantojot response.json()).

Veiktspējas apsvērumi

Runājot par veiktspēju, konteksts ir viss. Viena vienkārša pieprasījuma gadījumā veiktspējas atšķirība starp šīm trim bibliotēkām būs niecīga un, visticamāk, pazudīs tīkla latentumā.

Veiktspējas atšķirības patiesi parādās, apstrādājot konkurenci:

• requests daudzpavedienu vidē: Tas ir tradicionālais veids, kā sasniegt konkurenci ar `requests`. Tas darbojas, bet pavedieniem ir lielāks atmiņas patēriņš, un tie var ciest no konteksta pārslēgšanas izmaksām, īpaši, ja vienlaicīgo uzdevumu skaits pieaug līdz simtiem vai tūkstošiem.
• httpx ar asyncio: I/O saistītiem uzdevumiem, piemēram, API izsaukumiem, asyncio ir daudz efektīvāks. Tas izmanto vienu pavedienu un notikumu cilpu, lai pārvaldītu tūkstošiem vienlaicīgu savienojumu ar minimālām pieskaitāmām izmaksām. Ja jūsu lietojumprogrammai nepieciešams vienlaicīgi vaicāt simtiem mikropakalpojumu, httpx masveidā pārspēs pavedienu requests implementāciju.

Turklāt httpx atbalsts HTTP/2 var nodrošināt papildu veiktspējas pieaugumu, sazinoties ar serveri, kas to arī atbalsta, jo tas ļauj nosūtīt vairākus pieprasījumus pa to pašu TCP savienojumu, negaidot atbildes, tādējādi samazinot latentumu.

Pareizās bibliotēkas izvēle jūsu projektam

Balstoties uz šo dziļo analīzi, šeit ir mūsu praktiskie ieteikumi izstrādātājiem visā pasaulē:

Lietojiet httpx, ja...

Jūs sākat jebkuru jaunu Python projektu 2023. gadā vai vēlāk. Tā duālā sinhronā/asinhronā daba padara to par vispusīgāko un nākotnes drošāko variantu. Pat ja šodien jums ir nepieciešami tikai sinhroni pieprasījumi, httpx lietošana nozīmē, ka esat gatavs netraucētai pārejai uz asinhrono režīmu, ja jūsu lietojumprogrammas vajadzības mainīsies. Tā ir acīmredzama izvēle jebkuram projektam, kas ietver modernus tīmekļa ietvarus vai prasa augstu konkurences līmeni.

Lietojiet requests, ja...

Jūs strādājat pie mantotas koda bāzes, kas jau plaši izmanto requests. Migrācijas izmaksas var nebūt ieguvuma vērtas, ja lietojumprogramma ir stabila un tai nav konkurences prasību. Tā arī joprojām ir lieliska izvēle vienkāršiem, vienreizējiem skriptiem, kur asinhronās notikumu cilpas iestatīšanas pieskaitāmās izmaksas ir nevajadzīgas un lasāmība ir vissvarīgākā.

Lietojiet urllib3, ja...

Jūs esat bibliotēkas autors un jums ir jāveic HTTP pieprasījumi ar minimālām atkarībām un maksimālu kontroli. Atkarība no urllib3 ļauj izvairīties no requests vai httpx uzspiešanas saviem lietotājiem. Jums vajadzētu to izvēlēties arī tad, ja jums ir ļoti specifiskas, zema līmeņa prasības savienojumu vai TLS pārvaldībai, kuras augstāka līmeņa bibliotēkas nepiedāvā.

Noslēgums

Python HTTP klientu ainava piedāvā skaidru evolūcijas ceļu. `urllib3` nodrošina jaudīgu, stabilu dzinēju, kas ir ekosistēmas pamatā. `requests` uz šī dzinēja uzbūvēja API, kas bija tik intuitīvs un iemīļots, ka kļuva par globālu standartu, demokratizējot piekļuvi tīmeklim veselai Python programmētāju paaudzei. Tagad `httpx` ir moderns pēctecis, kas saglabā `requests` izcilo lietojamību, vienlaikus integrējot kritiskās funkcijas, kas nepieciešamas nākamās paaudzes programmatūrai: asinhronas operācijas un modernus tīkla protokolus.

Šodienas izstrādātājiem izvēle ir skaidrāka nekā jebkad agrāk. Kamēr `requests` joprojām ir uzticams rīks sinhroniem uzdevumiem, `httpx` ir uz nākotni vērsta izvēle praktiski visai jaunajai izstrādei. Izprotot katras bibliotēkas stiprās puses, jūs varat pārliecinoši izvēlēties pareizo rīku darbam, nodrošinot, ka jūsu lietojumprogrammas ir robustas, veiktspējīgas un gatavas nākotnei.